'use strict';
document.write("<script language='javascript' src='../../js/lay-module/layuimini/miniTab.js'></script>");
document.write("<script language='javascript' src='../../lib/layui-v2.6.3/layui.js'></script>");
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
    return typeof obj;
} : function (obj) {
    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};

// 判断两个对象是否相等
function objEquals(object1, object2) {
    for (var propName in object1) {
        if (object1.hasOwnProperty(propName) !== object2.hasOwnProperty(propName)) {
            return false;
        } else if (_typeof(object1[propName]) !== _typeof(object2[propName])) {
            return false;
        }
    }
    for (var _propName in object2) {
        if (object1.hasOwnProperty(_propName) !== object2.hasOwnProperty(_propName)) {
            return false;
        } else if (_typeof(object1[_propName]) !== _typeof(object2[_propName])) {
            return false;
        }
        if (!object1.hasOwnProperty(_propName)) {
            continue;
        }
        if (object1[_propName] instanceof Array && object2[_propName] instanceof Array) {
            if (objEquals(!object1[_propName], object2[_propName])) {
                return false;
            }
        } else if (object1[_propName] instanceof Object && object2[_propName] instanceof Object) {
            if (objEquals(!object1[_propName], object2[_propName])) {
                return false;
            }
        } else if (object1[_propName] !== object2[_propName]) {
            return false;
        }
    }
    return true;
}

//页面初始加载值
new Vue({
    el: '#app',
    data: function () {

        //alert(document.getElementById('seach').value)

        var specs = [];

        var parameterValue = [];
        return {
            specification: specs,
            // 提交数据格式
            productArray: parameterValue,
            // 用来存储要添加的规格属性
            addValues: [],
            // 默认商品编号
            defaultProductNo: 'PRODUCTNO_'
            // 批量设置相关
        };
    },
    methods: {
        // 提交
        submit: function (datas) {
            var specsData=[];
            var specificationdata = this.specification;//获取规格项目
            for (var i = 0; i <specificationdata.length; i++) {
                var specsVO={
                    trendTableSpecs:{
                        "name":specificationdata[i].name,
                        "value":specificationdata[i].value
                    },
                    "kindId":datas
                }
                specsData.push(specsVO)
            }
            $("#div_2").css("display", "block")
            layui.use(['layer'], function () {
                var miniTab = layui.miniTab;
                var layer = layui.layer;
                if (datas != "") {
                    $.ajax({
                        type : "POST",
                        contentType: "application/json; charset=utf-8",
                        data: JSON.stringify(specsData),
                        dataType: "json",
                        url:"/specs/addSpecsList",
                        async : true,
                        success : function(date){
                            if (date.code==0) {
                                layer.msg("添加成功");
                                miniTab.deleteCurrentByIframe();
                            }else {
                                layer.msg(date.msg, {icon: 5});
                            }
                        }
                    })
                    // $.post("/addskuDatas", {"dataresult": specificationdataStr, "kid": datas}, function (data) {
                    //     if (data == "ok") {
                    //         layer.msg('添加成功')
                    //         miniTab.deleteCurrentByIframe();
                    //     } else {
                    //         layer.msg('添加失败')
                    //     }
                    // })
                } else {
                    layer.msg('类别选择为空')
                }
            });

        },
        // 添加规格项目
        addSpec: function () {
            if (this.specification.length < 10) {

                this.specification.push({
                    name: '',
                    value: [],
                });


            }
        },
        // 删除规格项目
        delSpec: function (index) {
            this.specification.splice(index, 1);

            this.handleSpecChange('del');
        },
        // 添加规格属性
        addSpecTag: function (index) {
            var str = this.addValues[index] || '';
            if (!str.trim()) return; // 判空
            str = str.trim();
            var arr = str.split(/\s+/); // 使用空格分割成数组

            var newArr = this.specification[index].value.concat(arr);
            newArr = Array.from(new Set(newArr)); // 去重
            this.$set(this.specification[index], 'value', newArr);

            this.clearAddValues(index);

            this.handleSpecChange('add');
        },

        // 删除规格属性
        delSpecTag: function (index, num) {
            this.specification[index].value.splice(num, 1);

            this.handleSpecChange('del');
        },

        // 清空 addValues
        clearAddValues: function (index) {
            this.$set(this.addValues, index, '');
        },

        /*
    根据传入的属性值，拿到相应规格的属性
    @params
      specIndex 规格项目在 advancedSpecification 中的序号
      index 所有属性在遍历时的序号
  */
        getSpecAttr: function (specIndex, index) {
            // 获取当前规格项目下的属性值
            var currentValues = this.specification[specIndex].value;
            var indexCopy = void 0;

            // 判断是否是最后一个规格项目
            if (this.specification[specIndex + 1] && this.specification[specIndex + 1].value.length) {
                indexCopy = index / this.countSum(specIndex + 1);
            } else {
                indexCopy = index;
            }

            var i = Math.floor(indexCopy % currentValues.length);

            if (i.toString() !== 'NaN') {
                return currentValues[i];
            } else {
                return '';
            }
        },

        /*
    计算属性的乘积
    @params
      specIndex 规格项目在 advancedSpecification 中的序号
  */
        countSum: function (specIndex) {
            var num = 1;
            this.specification.forEach(function (item, index) {
                if (index >= specIndex && item.value.length) {
                    num *= item.value.length;
                }
            });
            return num;
        },

        // 根据传入的条件，来判断是否显示该td
        showTd: function (specIndex, index) {
            // 如果当前项目下没有属性，则不显示
            if (!this.specification[specIndex]) {
                return false;

                // 自己悟一下吧
            } else if (index % this.countSum(specIndex + 1) === 0) {
                return true;
            } else {
                return false;
            }
        },

        /**
         * [handleSpecChange 监听标签的变化,当添加标签时；求出每一行的hash id，再动态变更库存信息；当删除标签时，先清空已有库存信息，然后将原有库存信息暂存到stockCopy中，方便后面调用]
         * @param  {[string]} option ['add'|'del' 操作类型，添加或删除]
         * @return {[type]}        [description]
         */
        handleSpecChange: function (option) {
            var stockCopy = JSON.parse(JSON.stringify(this.productArray));
            if (option === 'del') {
                this.productArray = [];
            }

            for (var i = 0; i < this.countSum(0); i++) {
                this.changeStock(option, i, stockCopy);
            }
        },

        /**
         * [根据规格，动态改变库存相关信息]
         * @param  {[string]} option    ['add'|'del' 操作类型，添加或删除]
         * @param  {[array]} stockCopy [库存信息的拷贝]
         * @return {[type]}           [description]
         */
        changeStock: function (option, index, stockCopy) {
            var vm = this;
            var childProduct = {
                productId: 0,
                //asfdasdfaf阿斯顿发达东风
                // specs: this.specification,
                productSpec: this.getProductSpec(index),
                // productNo: this.defaultProductNo + index,
                // productStock: 0,
                // productPrice: 0
            };

            var spec = childProduct.productSpec;
            if (option === 'add') {
                if (this.stockSpecArr.findIndex(function (item) {
                    return objEquals(spec, item);
                }) === -1) {
                    this.$set(this.productArray, index, childProduct);
                }
            } else if (option === 'del') {
                // 因为是删除操作，理论上所有数据都能从stockCopy中获取到
                var origin = '';
                stockCopy.forEach(function (item) {
                    if (objEquals(spec, item.productSpec)) {
                        origin = item;
                        return false;
                    }
                });
                this.productArray.push(origin || childProduct);
            }
        },

        // 获取productArray的productSpec属性
        getProductSpec: function (index) {
            var _this = this;
            var obj = {};
            var i = 1;
            this.specification.forEach(function (item, specIndex) {
                // obj[item.name]=_this.getSpecAttr(specIndex, index);
                obj['vaule' + i] = _this.getSpecAttr(specIndex, index);
                i++;
                // obj['name']=item.name;
                // obj['value']=_this.getSpecAttr(specIndex, index);
                //
                // console.log(obj['name'])
                // console.log(obj['value'])
            });
            return obj;
        },

        // 生成不重复的商品编号
        makeProductNoNotRepet: function (index) {
            var No = void 0;
            var i = index;
            var isRepet = true;
            while (isRepet) {
                No = this.defaultProductNo + i;
                isRepet = this.isProductNoRepet(No);
                i++;
            }
            return No;
        },

        // 商品编号判重
        isProductNoRepet: function (No) {
            var result = this.productArray.findIndex(function (item) {
                return item.productNo === No;
            });
            return result > -1;
        }
    },
    computed: {
        // 所有sku的id
        stockSpecArr: function () {
            return this.productArray.map(function (item) {
                return item.productSpec;
            });
        }
    },
});